;(self.webpackChunkmp_webgl = self.webpackChunkmp_webgl || []).push([
  [838],
  {
    12629: (e, t, r) => {
      "use strict"
      r.r(t), r.d(t, { loadInterface: () => pt })
      var o,
        a,
        n,
        s,
        i,
        d,
        c,
        u = r(84303)
      !(function (e) {
        ;(e.FORWARD = "FORWARD"), (e.LEFT = "LEFT"), (e.RIGHT = "RIGHT"), (e.BACK = "BACK"), (e.UP = "UP"), (e.DOWN = "DOWN")
      })(o || (o = {}))
      !(function (e) {
        ;(e.INSIDE = "mode.inside"),
          (e.OUTSIDE = "mode.outside"),
          (e.DOLLHOUSE = "mode.dollhouse"),
          (e.FLOORPLAN = "mode.floorplan"),
          (e.TRANSITIONING = "mode.transitioning")
      })(a || (a = {}))
      !(function (e) {
        ;(e.INSTANT = "transition.instant"), (e.FLY = "transition.fly"), (e.FADEOUT = "transition.fade"), (e.MOVEFADE = "transition.movefade")
      })(n || (n = {}))
      class convertRotation_Conversion {
        constructor(e) {
          ;(this.THREE = e), (this.tempEuler = new e.Euler())
        }
        quaternionToRotation(e, t) {
          const r = this.tempEuler.setFromQuaternion(e, convertRotation_Conversion.eulerOrder),
            o = t || {}
          return (o.x = this.THREE.MathUtils.radToDeg(r.x)), (o.y = this.THREE.MathUtils.radToDeg(r.y)), (o.z = this.THREE.MathUtils.radToDeg(r.z)), o
        }
        rotationToQuaternion(e, t) {
          const r = t || new this.THREE.Quaternion()
          return (
            (this.tempEuler.x = this.THREE.MathUtils.degToRad(e.x)),
            (this.tempEuler.y = this.THREE.MathUtils.degToRad(e.y)),
            (this.tempEuler.z = this.THREE.MathUtils.degToRad(e.z || 0)),
            (this.tempEuler.order = convertRotation_Conversion.eulerOrder),
            r.setFromEuler(this.tempEuler)
          )
        }
      }
      ;(convertRotation_Conversion.eulerOrder = "YXZ"),
        (function (e) {
          ;(e.LEGACY = "legacy"), (e.API = "api")
        })(s || (s = {})),
        (function (e) {
          ;(e.PHASE_CHANGE = "application.phasechange"), (e.APP_CHANGE = "application.appchange")
        })(i || (i = {})),
        (function (e) {
          ;(e.UNKNOWN = "application.unknown"), (e.WEBVR = "application.webvr"), (e.SHOWCASE = "application.showcase"), (e.WORKSHOP = "application.workshop")
        })(d || (d = {})),
        (function (e) {
          ;(e.UNINITIALIZED = "appphase.uninitialized"),
            (e.WAITING = "appphase.waiting"),
            (e.LOADING = "appphase.loading"),
            (e.STARTING = "appphase.starting"),
            (e.PLAYING = "appphase.playing"),
            (e.ERROR = "appphase.error")
        })(c || (c = {}))
      Math.PI
      var l
      !(function (e) {
        e.MOVE = "camera.move"
      })(l || (l = {}))
      var p = r(88512)
      new p.Z("broadcast.move")
      new p.Z("command.zoom")
      var h, g, m, w, T, E
      !(function (e) {
        ;(e.CHANGE_START = "floors.changestart"), (e.CHANGE_END = "floors.changeend")
      })(h || (h = {})),
        (function (e) {
          e.POSITION_UPDATED = "label.positionupdated"
        })(g || (g = {})),
        (function (e) {
          ;(e.HOVER = "tag.hover"), (e.CLICK = "tag.click"), (e.LINK_OPEN = "tag.linkopen")
        })(m || (m = {})),
        (function (e) {
          ;(e.NONE = "mattertag.media.none"), (e.PHOTO = "mattertag.media.photo"), (e.VIDEO = "mattertag.media.video"), (e.RICH = "mattertag.media.rich")
        })(w || (w = {})),
        (function (e) {
          ;(e.NONE = "tag.chunk.none"), (e.TEXT = "tag.chunk.text"), (e.LINK = "tag.chunk.link")
        })(T || (T = {})),
        (function (e) {
          ;(e.NAVIGATION = "tag.link.nav"), (e.MODEL = "tag.link.model"), (e.EXT_LINK = "tag.link.ext")
        })(E || (E = {}))
      r(20331)
      const S = new p.Z("sdk.editIcon")
      class SvgLoader {
        constructor(e) {
          this.queue = e
        }
        async load(e) {
          const t = await this.queue.get(e, { responseType: "text" }),
            r = document.createElement("div")
          r.innerHTML = t
          const o = r.querySelector("svg")
          if (!o) throw Error("Failed trying to load " + e + "as an svg.")
          const a = o.getAttribute("width"),
            n = o.getAttribute("height")
          return (
            a || n
              ? (n && !a && (S.warn(e, "does not have a defined width. Defaulting width equal to height"), o.setAttribute("width", n)),
                a && !n && (S.warn(e, "does not have a defined height. Defaulting height equal to width"), o.setAttribute("height", a)))
              : (S.warn(e, "does not have a defined size. Defaulting to a 128x128 resolution"),
                o.setAttribute("width", SvgLoader.defaultResolution),
                o.setAttribute("height", SvgLoader.defaultResolution)),
            new Promise(e => {
              const t = new Image()
              ;(t.onload = () => e(t)), (t.src = URL.createObjectURL(new Blob([o.outerHTML], { type: "image/svg+xml" })))
            })
          )
        }
      }
      SvgLoader.defaultResolution = "128"
      new p.Z("util")
      new p.Z("mattertag-util")
      var f
      !(function (e) {
        ;(e.LABEL = "label"), (e.DESCRIPTION = "description"), (e.MEDIA = "media")
      })(f || (f = {}))
      new p.Z("command.editOpacity")
      var I
      r(2815), r(24800)
      !(function (e) {
        ;(e.CHANGE_START = "viewmode.changestart"), (e.CHANGE_END = "viewmode.changeend")
      })(I || (I = {}))
      new p.Z("move-to-mode-command")
      var C, O, y, D, N
      !(function (e) {
        e.MODEL_LOADED = "model.loaded"
      })(C || (C = {})),
        (function (e) {
          ;(e.NONE = "intersectedobject.none"),
            (e.MODEL = "intersectedobject.model"),
            (e.TAG = "intersectedobject.tag"),
            (e.SWEEP = "intersectedobject.sweep"),
            (e.UNKNOWN = "intersectedobject.unknown")
        })(O || (O = {}))
      !(function (e) {
        ;(e.Base64JPG = "screenshot.base64.jpg"), (e.ArrayBufferJPG = "screenshot.arraybuffer.jpg")
      })(y || (y = {}))
      class EquirectangularExecutor {
        constructor(e, t, r) {
          ;(this.Viewmode = t.Viewmode),
            (this.requestTarget = r.requestTarget),
            (this.encodeRenderTarget = r.encodeRenderTarget),
            (this.jpegAsBase64 = r.jpegAsBase64),
            (this.getXmp = r.getXmp),
            (this.getOrientedAngleTo = r.getOrientedAngleTo),
            (this.forward = new e.Vector3(0, 0, -1)),
            (this.sweepForward = new e.Vector3()),
            (this.viewForward = new e.Vector3())
        }
        validateInput(e) {
          return e
        }
        async exec(e, t, r, o, a, n, s) {
          if (!n.currentSweep || a.currentMode !== this.Viewmode.Panorama)
            throw new Error("Can only capture equirectangular projections while stationary in a sweep")
          const i = r.getScene().camera,
            d = n.getSweep(n.currentSweep),
            c = await s.load(d)
          this.sweepForward.copy(this.forward), this.sweepForward.copy(this.forward).applyQuaternion(d.rotation).setY(0)
          const u = this.getOrientedAngleTo(this.sweepForward, i.getWorldDirection(this.viewForward).setY(0)) + Math.PI,
            l = await this.requestTarget()
          l.setSize(EquirectangularExecutor.equirectangularRes.width, EquirectangularExecutor.equirectangularRes.height),
            o.renderEquirectangular(c, l.target, u)
          const p = await this.encodeRenderTarget(l, this.getXmp(l.width, l.height, 0, 0))
          t.return(this.jpegAsBase64(p))
        }
      }
      ;(EquirectangularExecutor.equirectangularRes = {
        width: 4096,
        height: 2048
      }),
        (function (e) {
          ;(e.CLICK = "INTERACTION.CLICK"),
            (e.HOVER = "INTERACTION.HOVER"),
            (e.DRAG = "INTERACTION.DRAG"),
            (e.DRAG_BEGIN = "INTERACTION.DRAG_BEGIN"),
            (e.DRAG_END = "INTERACTION.DRAG_END"),
            (e.POINTER_MOVE = "INTERACTION.POINTER_MOVE"),
            (e.POINTER_BUTTON = "INTERACTION.POINTER_BUTTON"),
            (e.SCROLL = "INTERACTION.SCROLL"),
            (e.KEY = "INTERACTION.KEY"),
            (e.LONG_PRESS_START = "INTERACTION.LONG_PRESS_START"),
            (e.LONG_PRESS_END = "INTERACTION.LONG_PRESS_END"),
            (e.MULTI_SWIPE = "INTERACTION.MULTI_SWIPE"),
            (e.MULTI_SWIPE_END = "INTERACTION.MULTI_SWIPE_END"),
            (e.PINCH = "INTERACTION.PINCH"),
            (e.PINCH_END = "INTERACTION.PINCH_END"),
            (e.ROTATE = "INTERACTION.ROTATE"),
            (e.ROTATE_END = "INTERACTION.ROTATE_END")
        })(D || (D = {})),
        (function (e) {
          ;(e.OBJ_LOADER = "mp.objLoader"),
            (e.FBX_LOADER = "mp.fbxLoader"),
            (e.DAE_LOADER = "mp.daeLoader"),
            (e.GLTF_LOADER = "mp.gltfLoader"),
            (e.SCROLLING_TUBE = "mp.scrollingTube"),
            (e.TRANSFORM_CONTROLS = "mp.transformControls"),
            (e.LIGHTS_COMPONENT = "mp.lights"),
            (e.POINT_LIGHT = "mp.pointLight"),
            (e.DIRECTIONAL_LIGHT = "mp.directionalLight"),
            (e.AMBIENT_LIGHT = "mp.ambientLight"),
            (e.CAMERA = "mp.camera"),
            (e.INPUT = "mp.input"),
            (e.XR = "mp.xr")
        })(N || (N = {}))
      class SensorReadingCollection {
        constructor() {
          ;(this.sourceMap = new Map()), (this.reverseSourceLookup = new Map()), (this.sourceId = 0), (this._data = {})
        }
        get data() {
          return this._data
        }
        isItemEqual(e, t) {
          return e.data[t].inRange === this.data[t].inRange && e.data[t].inView === this.data[t].inView
        }
        update(e) {
          for (const [a, n] of e.readings) {
            const e = this.addOrGetSourceId(a),
              s = this._data[e] || {}
            ;(s.inRange = n.inRange),
              (s.inView = n.inView),
              (s.distanceSquared = n.distanceSq),
              (s.direction = ((t = n), (r = "direction"), ((o = (o = s.direction) || {}).x = t[r].x), (o.y = t[r].y), (o.z = t[r].z), o)),
              (this._data[e] = s)
          }
          var t, r, o
          for (const t in this.data) {
            const r = this.reverseSourceLookup.get(t)
            r && !e.readings.get(r) && (this.sourceMap.delete(r), this.reverseSourceLookup.delete(t), delete this._data[t])
          }
        }
        clear() {
          this._data = {}
        }
        addOrGetSourceId(e) {
          const t = this.sourceMap.get(e)
          if (t) return t
          const r = "source-" + ++this.sourceId
          return this.sourceMap.set(e, r), this.reverseSourceLookup.set(r, e), r
        }
      }
      class DependencyFetcher_DependencyFetcher {
        constructor(...e) {
          this.dependencies = e
        }
        async getDependencies() {
          return Promise.all(this.dependencies)
        }
        static extend(e, ...t) {
          return new DependencyFetcher_DependencyFetcher(...e.dependencies, ...t)
        }
        static combine(e, t) {
          return new DependencyFetcher_DependencyFetcher(...e.dependencies, ...t.dependencies)
        }
      }
      class ClassFactory_ClassFactory {
        constructor(e, ...t) {
          ;(this.ctor = e), (this.args = t)
        }
        create() {
          return new this.ctor(...this.args)
        }
      }
      class SdkCollection_SdkCollection {
        constructor(e, t, r) {
          ;(this.dependencies = e), (this.subscriptionFactory = t), (this.observers = new Set()), (this.currentData = r.create()), (this.freshData = r.create())
        }
        static async create(e, t, r) {
          const o = await e.getDependencies()
          return new SdkCollection_SdkCollection(o, t, r)
        }
        getData() {
          return this.currentData.data
        }
        observe(e) {
          return (
            this.addObserver(e),
            new (class ObserverSubscription {
              constructor(e) {
                ;(this.sdkCollection = e), this.renew()
              }
              renew() {
                this.sdkCollection.addObserver(e)
              }
              cancel() {
                this.sdkCollection.removeObserver(e)
              }
            })(this)
          )
        }
        addObserver(e) {
          class CollectionChangeObserver {
            constructor(e) {
              this.sdkCollection = e
            }
            onChanged() {
              const { freshData: e, currentData: t, dependencies: r } = this.sdkCollection
              e.update(...r)
              let o = !1
              for (const r in e.data)
                if (t.data.hasOwnProperty(r)) {
                  if (!t.isItemEqual(e, r)) for (const t of this.sdkCollection.observers) t.onUpdated(r, e.data[r]), (o = !0)
                } else for (const t of this.sdkCollection.observers) t.onAdded(r, e.data[r]), (o = !0)
              for (const r in t.data) if (!e.data.hasOwnProperty(r)) for (const e of this.sdkCollection.observers) e.onRemoved(r), (o = !0)
              if (o) for (const e of this.sdkCollection.observers) e.onCollectionUpdated()
              const a = t
              ;(this.sdkCollection.currentData = this.sdkCollection.freshData), (this.sdkCollection.freshData = a)
            }
          }
          if (!this.observers.has(e))
            if ((this.observers.add(e), 1 === this.observers.size)) {
              const e = new CollectionChangeObserver(this)
              ;(this.changeSubscription = this.subscriptionFactory.create(e, ...this.dependencies)), e.onChanged()
            } else for (const t in this.currentData.data) e.onAdded(t, this.currentData.data[t])
        }
        removeObserver(e) {
          0 !== this.observers.size && (this.observers.delete(e), 0 === this.observers.size && (this.changeSubscription.cancel(), this.currentData.clear()))
        }
      }
      var b = r(94326),
        R = r(40918)
      function v(e, t) {
        !(function (e, t) {
          ;(e.x = t.x), (e.y = t.y)
        })(e, t),
          (e.z = t.z)
      }
      var A = r(66363)
      class SensorStateObservable {
        constructor() {
          this._data = {
            origin: { x: 0, y: 0, z: 0 },
            forward: { x: 0, y: 0, z: -1 }
          }
        }
        get data() {
          return this._data
        }
        equals(e) {
          const t = 1e-5
          return (0, A.wo)(this.data.origin, e.data.origin, t) && (0, A.wo)(this.data.forward, e.data.forward, t)
        }
        copy(e) {
          v(this._data.origin, e.data.origin), v(this._data.forward, e.data.forward)
        }
        update(e) {
          v(this._data.origin, e.frustum.origin), v(this._data.forward, e.frustum.forward)
        }
      }
      function M(e, t) {
        return Object.values(e).includes(t)
      }
      class executor_createSensor_CreateSensorExecutor {
        constructor(e, t) {
          ;(this.sdkModule = e), (this.sensorFactories = t)
        }
        validateInput(e) {
          if (!M(b.dE, e.type)) throw Error(e.type + " is not a valid sensor type")
          return this.sensorFactories[e.type].validateInput(e)
        }
        async exec(e, t, r, o, a) {
          const n = this.sensorFactories[e.type].create(e, r),
            s = "sensor-" + ++executor_createSensor_CreateSensorExecutor.nextSensorId
          o.set(s, n)
          const i = R.l.create(
              new DependencyFetcher_DependencyFetcher(n),
              new SensorStateSubscriptionFactory(),
              new ClassFactory_ClassFactory(SensorStateObservable)
            ),
            d = this.sdkModule.addObservable(s, i),
            c = SdkCollection_SdkCollection.create(
              new DependencyFetcher_DependencyFetcher(n),
              new SensorReadingSubscriptionFactory(),
              new ClassFactory_ClassFactory(SensorReadingCollection)
            ),
            u = this.sdkModule.addCollection(s, c)
          a.set(s, {
            dispose() {
              d.dispose(), u.dispose()
            }
          }),
            t.return({ sensorId: s })
        }
      }
      executor_createSensor_CreateSensorExecutor.nextSensorId = 0
      class SensorStateSubscriptionFactory {
        create(e, t) {
          return t.frustum.observe(new DependencyObserverAdaptor(e))
        }
      }
      class SensorReadingSubscriptionFactory {
        create(e, t) {
          return t.onReadingsUpdated(new DependencyObserverAdaptor(e))
        }
      }
      class DependencyObserverAdaptor {
        constructor(e) {
          this.dependencyObserver = e
        }
        notify() {
          this.dependencyObserver.onChanged()
        }
      }
      var _ = r(60402)
      Math.PI
      class executor_createSource_CreateSourceExecutor {
        constructor(e) {
          this.sourceFactories = e
        }
        validateInput(e, t) {
          if (!M(_.PO, e.type)) throw Error(e.type + " is not a valid source type")
          return this.sourceFactories[e.type].validateInput(e)
        }
        exec(e, t, r) {
          const o = this.sourceFactories[e.type].create(e),
            a = "source-" + ++executor_createSource_CreateSourceExecutor.nextSourceId
          r.set(a, o), t.return({ sourceId: a, type: e.type, volume: o.describeVolume() })
        }
      }
      executor_createSource_CreateSourceExecutor.nextSourceId = 0
      var L, P, k
      !(function (e) {
        e.FPS = "stat.fps"
      })(L || (L = {}))
      !(function (e) {
        ;(e.ALIGNED = "aligned"), (e.UNALIGNED = "unaligned")
      })(P || (P = {})),
        (function (e) {
          ;(e.UNPLACED = "unplaced"), (e.AUTO = "auto"), (e.MANUAL = "manual")
        })(k || (k = {}))
      var F,
        x,
        G = r(68524)
      class CurrentSweepObservable {
        constructor(e, t) {
          ;(this.currentSweep = Object.assign(Object.assign({}, CurrentSweepObservable.empty), {
            floorInfo: Object.assign({}, CurrentSweepObservable.empty.floorInfo),
            neighbors: [],
            position: Object.assign({}, CurrentSweepObservable.empty.position),
            rotation: Object.assign({}, CurrentSweepObservable.empty.rotation)
          })),
            (this.Viewmode = e.Viewmode),
            (this.sweepPlacementConverter = t.sweepPlacementConverter)
        }
        get data() {
          return this.currentSweep
        }
        equals(e) {
          const t = G.Z.epsilon
          return (
            this.currentSweep.id === e.data.id &&
            this.currentSweep.enabled === e.data.enabled &&
            this.currentSweep.alignmentType === e.data.alignmentType &&
            this.currentSweep.placementType === e.data.placementType &&
            this.currentSweep.floorInfo.id === e.data.floorInfo.id &&
            this.currentSweep.floorInfo.sequence === e.data.floorInfo.sequence &&
            this.compareNeighbors(e.currentSweep) &&
            (0, A.wo)(this.currentSweep.position, e.data.position, t) &&
            (0, A.wo)(this.currentSweep.rotation, e.data.rotation, t)
          )
        }
        copy(e) {
          this.copySweep(e.data)
        }
        update(e, t, r, o, a) {
          const n = e.currentSweepObject
          if (!n || e.transition.active || t.transition.active || (!t.isInside() && t.currentMode !== this.Viewmode.Outdoor))
            return void this.copySweep(CurrentSweepObservable.empty)
          let s
          try {
            s = r.getFloor(n.floorId || "")
          } catch (e) {
            s = { id: void 0, index: void 0 }
          }
          const i = o.getIdForSweep(n)
          ;(this.currentSweep.uuid = n.uuid),
            (this.currentSweep.sid = i),
            (this.currentSweep.id = i),
            (this.currentSweep.enabled = n.enabled),
            (this.currentSweep.alignmentType = this.sweepPlacementConverter.toSdkAlignment(n.alignmentType)),
            (this.currentSweep.placementType = this.sweepPlacementConverter.toSdkPlacement(n.placementType)),
            (this.currentSweep.neighbors = [...n.neighbours]),
            v(this.currentSweep.position, n.position),
            v(this.currentSweep.rotation, n.rotation),
            this.currentSweep.alignmentType === P.UNALIGNED && this.currentSweep.placementType === k.UNPLACED
              ? ((this.currentSweep.floorInfo.id = void 0), (this.currentSweep.floorInfo.sequence = void 0))
              : ((this.currentSweep.floorInfo.id = s.id ? a.getIdFromCwfId(s.id) : s.id), (this.currentSweep.floorInfo.sequence = s.index))
        }
        copySweep(e) {
          ;(this.currentSweep.uuid = e.uuid),
            (this.currentSweep.sid = e.sid),
            (this.currentSweep.id = e.id),
            (this.currentSweep.enabled = e.enabled),
            (this.currentSweep.alignmentType = e.alignmentType),
            (this.currentSweep.placementType = e.placementType),
            (this.currentSweep.floorInfo.id = e.floorInfo.id),
            (this.currentSweep.floorInfo.sequence = e.floorInfo.sequence),
            (this.currentSweep.neighbors = [...e.neighbors]),
            v(this.currentSweep.position, e.position),
            v(this.currentSweep.rotation, e.rotation)
        }
        compareNeighbors(e) {
          const t = this.currentSweep.neighbors.length
          for (let r = 0; r < t; ++r) if (this.currentSweep.neighbors[r] !== e.neighbors[r]) return !1
          return t === e.neighbors.length
        }
      }
      ;(CurrentSweepObservable.empty = {
        uuid: "",
        sid: "",
        id: "",
        enabled: !1,
        alignmentType: P.ALIGNED,
        placementType: k.UNPLACED,
        floorInfo: { id: void 0, sequence: void 0 },
        neighbors: [],
        position: { x: 0, y: 0, z: 0 },
        rotation: { x: 0, y: 0, z: 0 }
      }),
        (function (e) {
          ;(e.ENTER = "sweep.enter"), (e.EXIT = "sweep.exit")
        })(F || (F = {}))
      !(function (e) {
        ;(e.STARTED = "tour.started"), (e.STOPPED = "tour.stopped"), (e.ENDED = "tour.ended"), (e.STEPPED = "tour.stepped")
      })(x || (x = {}))
      new p.Z("sdk: tours")
      var U = r(8684),
        H = r(96909),
        V = r(66223),
        q = r(87202),
        B = r(76463),
        j = r(69626),
        z = r(27687),
        Z = r(84561),
        W = r(3248),
        K = r(8150),
        Y = r(31278),
        X = r(49924),
        J = r(90454),
        Q = r(76896),
        $ = r(2725),
        ee = r(98649),
        te = r(41663),
        re = r(34986),
        oe = r(90756),
        ae = r(46610),
        ne = r(60225),
        se = r(58014),
        ie = r(36123),
        de = r(29422),
        ce = r(48470),
        ue = r(40554),
        le = r(42835),
        pe = r(61709),
        he = r(17386)
      class SettingGetCommand extends he.m {
        constructor(e) {
          super(), (this.payload = { key: e })
        }
      }
      SettingGetCommand.id = "SETTING_GET"
      class SettingUpdateCommand extends he.m {
        constructor(e, t) {
          super(), (this.payload = { key: e, value: t })
        }
      }
      SettingUpdateCommand.id = "SETTING_UPDATE"
      var ge = r(16101),
        me = r(35026),
        we = r(29397),
        Te = r(85895),
        Ee = r(92532),
        Se = r(79553),
        fe = r(91302),
        Ie = r(87068),
        Ce = r(12216),
        Oe = r(94329),
        ye = r(3805),
        De = r(68576),
        Ne = r(88814),
        be = r(21479),
        Re = r(59088),
        ve = r(40168),
        Ae = r(26627),
        Me = r(27326),
        _e = r(74371),
        Le = r(40698),
        Pe = r(58626),
        ke = r(60725),
        Fe = r(38003),
        xe = r(8445),
        Ge = r(44019),
        Ue = r(86488),
        He = r(33874),
        Ve = r(75892),
        qe = r(65379),
        Be = r(69941),
        je = r(35597),
        ze = r(15982),
        Ze = r(21499),
        We = r(36822),
        Ke = r(13988),
        Ye = r(14880),
        Xe = r(86122),
        Je = r(92895),
        Qe = r(87738),
        $e = r(44218),
        et = r(29539),
        tt = r(32306),
        rt = r(1466),
        ot = r(13827),
        at = r(88269),
        nt = r(3198),
        st = r(9576),
        it = r(55105),
        dt = r(24930),
        ct = r(31657),
        ut = r(2212),
        lt = r(67027)
      async function pt(e, t, r) {
        const o = await (async function () {
            return "./sdk/sdk-interface.js"
          })(),
          a = new U.M()
        let n
        try {
          n = await a.load(o)
        } catch (e) {
          throw Error("Unable to fetch the sdk interface. The sdk will be disabled. " + e)
        }
        const i = { THREE: ut },
          d = {
            RenderLayers: Z.o,
            OptionsKey: W.gx,
            Application: be.Mx,
            AppPhase: be.nh,
            AppPhaseChangeMessage: K.LZ,
            CameraTransitionType: Y.n,
            GetFloorIntersectCommand: X.Z,
            StartMoveToFloorMessage: J.S,
            EndMoveToFloorMessage: Q.P,
            MoveToFloorIndexCommand: $.h9,
            ShowAllFloorsCommand: $.EU,
            MattertagMediaType: ee.L,
            RemoveMattertagCommand: te.Gn,
            TagDescriptionChunkType: re.z,
            TagLinkType: oe.U,
            AddMattertagCommand: te.Fz,
            EditMattertagCommand: te.Ek,
            MattertagLinkOpenedMessage: ae.Ik,
            NavigateToMattertagCommand: ne.Y,
            ModelDataLoadedMessage: se.Z,
            ModelColliderTarget: ie.S,
            NavigateToSweepCommand: de.ju,
            MeasuringPhase: ke.au,
            SettingGetCommand: SettingGetCommand,
            SettingUpdateCommand: SettingUpdateCommand,
            PuckCollider: ge.YY,
            PinClickedMessage: ce.F7,
            PinHoverChangeMessage: ce.tP,
            PinHeadMesh: ue.$,
            InstancedPinHeads: pe.z,
            PinType: le.Er,
            SweepAlignmentType: me.z9,
            SweepPlacementType: me.hU,
            BeginMoveToSweepMessage: we.Z,
            EndMoveToSweepMessage: Te.Z,
            ToggleToolCommand: Ee.tT,
            Tools: Se.w1,
            TourStartedMessage: fe.oR,
            TourStoppedMessage: fe.NR,
            TourEndedMessage: fe.Mt,
            TourSteppedMessage: fe.Vx,
            Color: Ie.I,
            Vectors: Ce.f,
            Viewmode: Oe.Ey,
            CommandViewmode: ye.BD,
            ChangeViewmodeCommand: ye._i,
            BeginSwitchViewmodeMessage: De.Z,
            EndSwitchViewmodeMessage: Ne.Z,
            GetScreenPositionCommand: ze.b,
            ZoomInCommand: Ze.bj,
            ZoomResetCommand: Ze.ob,
            ZoomSetCommand: Ze.ts,
            SourceType: ot.SourceType,
            sensorVolumes: { sphere: at.b, box: nt.k, cylinder: st.X }
          },
          c = ht(t),
          u = (function (e) {
            const t = (async () => {
              const t = (await e.getModule($e.default)).getSignedUrls()
              return new B.Z(t)
            })()
            return {
              applicationData: e.market.waitForData(be.pu),
              cameraData: e.market.waitForData(Re.M_),
              canvasData: e.market.waitForData(ve.W),
              floorData: e.market.waitForData(Ae.i),
              floorViewData: e.market.waitForData(Me.c),
              labelData: e.market.waitForData(_e.D),
              mattertagData: e.market.waitForData(Le.n),
              mattertagViewData: e.market.waitForData(Pe.P5),
              measurementModeData: e.market.waitForData(Fe.X),
              modelData: e.market.waitForData(xe.T),
              raycasterData: e.market.waitForData(Ge.P),
              roomData: e.market.waitForData(Ue.Z),
              settingsData: e.market.waitForData(He.e),
              sweepData: e.market.waitForData(Ve.Z),
              sweepViewData: e.market.waitForData(qe.D),
              tourData: e.market.waitForData(Be.k3),
              viewmodeData: e.market.waitForData(je.O),
              appPhaseModule: e.getModule(We.default),
              commonControlsModule: e.getModule(Ke.default),
              floorCasterModule: e.getModule(Ye.default),
              mattertagDataModule: e.getModule(Xe.default),
              mattertagMeshModule: e.getModule(Je.default),
              mattertagViewDataModule: e.getModule(Qe.default),
              modelDataModule: e.getModule($e.default),
              modelMeshModule: e.getModuleBySymbol(H.y.MODEL_MESH),
              meshData: e.market.waitForData(lt._),
              navigationModule: e.getModule(et.default),
              renderToTextureModule: e.getModule(tt.default),
              sceneModule: e.getModuleBySymbol(H.y.SCENE),
              sensorModule: e.getModule(it.K),
              settingsModule: e.getModule(dt.default),
              tourControlsModule: e.getModuleBySymbol(H.y.TOUR_CONTROLS),
              webglRendererModule: e.getModuleBySymbol(H.y.WEBGL_RENDERER),
              zoomControlModule: e.getModule(ct.default),
              sweepTextureLoader: t
            }
          })(t),
          l = new URLSearchParams(window.location.search).get("useLegacyIds"),
          p = null === l || parseInt(l, 10) ? s.LEGACY : s.API
        n.setup(e, i, d, c, u, { idOption: p })
      }
      function ht(e) {
        return {
          loadImage: V.p,
          waitForUpdate: () => e.after(u.A.End),
          subscribe: (t, r) => e.subscribe(t, r),
          addBinding: (t, r) => e.commandBinder.addBinding(t, r),
          issueCommand: t => e.commandBinder.issueCommand(t),
          requestTarget: () => e.commandBinder.issueCommand(new q.oM()),
          getRenderLayer: t => e.getRenderLayer(t),
          jpegAsBase64: rt.jJ,
          encodeRenderTarget: rt.vP,
          getXmp: rt.fY,
          getOrientedAngleTo: j.k2,
          screenPositionToNDC: z.z5,
          ndcToWorldPosition: z.st,
          worldToScreenPosition: z.q9
        }
      }
    }
  }
])
